const double eps = 1E-9;
const double INF = 1E+40;
const double PI = 2.0 * acos(0.0);
class point 
{
public:
        double x, y;
        point (double _x = 0, double _y = 0)
		{
			x = _x, y = _y;
		}
};
double get_ang (point a, point b) 
{
        double ang1 = atan2(a.y, a.x);
        double ang2 = atan2(b.y, b.x);
        double ang = abs(ang1 - ang2);
        return min(ang, 2*PI-ang);
}
point vec (point a, point b) 
{
        return point(b.x - a.x, b.y - a.y);
}
double dist (point a, point b) 
{
        return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double get_h (double a, double alpha, double beta) 
{
        return a * sin(alpha) * sin(beta) / sin(alpha+beta);
}
double det (double a, double b, double c, double d) 
{
        return a * d - b * c;
}

point intersect_line (point p1, point p2, point q1, point q2) 
{
        double a1 = p1.y - p2.y;
        double b1 = p2.x - p1.x;
        double c1 = - a1 * p1.x - b1 * p1.y;        
		double a2 = q1.y - q2.y;
        double b2 = q2.x - q1.x;
        double c2 = - a2 * q1.x - b2 * q1.y;
        return point(
                - det(c1, b1, c2, b2) / det(a1, b1, a2, b2),
                - det(a1, c1, a2, c2) / det(a1, b1, a2, b2)
                );
}

bool parallel (point p1, point p2, point q1, point q2) 
{
        double a1 = p1.y - p2.y;
        double b1 = p2.x - p1.x;
        double a2 = q1.y - q2.y;
        double b2 = q2.x - q1.x;
        return abs(det(a1, b1, a2, b2)) < eps;
}
double calc_val (point p1, point p2, point q1, point q2, point r1, point r2) 
{
        point l1 = intersect_line (p1, p2, q1, q2);
        point l2 = intersect_line (p1, p2, r1, r2);
        return get_h(
			dist (l1, l2), 
			get_ang(vec(q1,q2),vec(p1,p2)) / 2,
            get_ang(vec(r1,r2),vec(p2,p1)) / 2
			);
}

double inner_circle(vector <point> &a)
// method Mf
{
        int n = a.size();
        set < pair <double,int> > q;
        vector <double> val (n);
        forx(i, n)
		{
                point &p1 = a[i],  &p2 = a[(i+1)%n],  &q1 = a[(i-1+n)%n],  &q2 = a[(i+2)%n];
                val[i] = calc_val(p1, p2, p1, q1, p2, q2);
                q.insert (make_pair (val[i], i));
        }

        vector<int> next (n), prev (n);
        forx(i, n) 
		{
                next[i] = (i + 1) % n;
                prev[i] = (i - 1 + n) % n;
        }
        
		double last_time = -1.0;
        while (q.size() > 2) 
		{
                last_time = q.begin()->first;
                int id = q.begin()->second;
                q.erase (q.begin());

                val[id] = -1;
                next[prev[id]] = next[id];
                prev[next[id]] = prev[id];
                int nxt = next[id],  prv = prev[id];
                
				if (parallel(a[nxt], a[(nxt+1)%n], a[prv], a[(prv+1)%n]))
					break;
                
				q.erase(make_pair(val[nxt], nxt));
                q.erase(make_pair(val[prv], prv));
                val[nxt] = calc_val(
						a[nxt], 
						a[(nxt + 1) % n], 
						a[(prv + 1) % n],
                        a[prv], 
						a[next[nxt]], 
						a[(next[nxt] + 1) % n]
						);
                val[prv] = calc_val(
					a[prv], 
					a[(prv + 1) % n], 
					a[(prev[prv] + 1) % n], 
					a[prev[prv]], 
					a[nxt], 
					a[(nxt + 1) % n]
					);
                q.insert(make_pair(val[nxt], nxt));
                q.insert(make_pair(val[prv], prv));
        }
        return last_time;
}
